home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / djgpp / src / gdb-4.12 / gdb / gdbtypes.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-03  |  44.0 KB  |  1,536 lines
  1. /* Support routines for manipulating internal types for GDB.
  2.    Copyright (C) 1992 Free Software Foundation, Inc.
  3.    Contributed by Cygnus Support, using pieces from other GDB modules.
  4.  
  5. This file is part of GDB.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include "defs.h"
  22. #include <string.h>
  23. #include "bfd.h"
  24. #include "symtab.h"
  25. #include "symfile.h"
  26. #include "objfiles.h"
  27. #include "gdbtypes.h"
  28. #include "expression.h"
  29. #include "language.h"
  30. #include "target.h"
  31. #include "value.h"
  32. #include "demangle.h"
  33. #include "complaints.h"
  34.  
  35. /* These variables point to the objects
  36.    representing the predefined C data types.  */
  37.  
  38. struct type *builtin_type_void;
  39. struct type *builtin_type_char;
  40. struct type *builtin_type_short;
  41. struct type *builtin_type_int;
  42. struct type *builtin_type_long;
  43. struct type *builtin_type_long_long;
  44. struct type *builtin_type_signed_char;
  45. struct type *builtin_type_unsigned_char;
  46. struct type *builtin_type_unsigned_short;
  47. struct type *builtin_type_unsigned_int;
  48. struct type *builtin_type_unsigned_long;
  49. struct type *builtin_type_unsigned_long_long;
  50. struct type *builtin_type_float;
  51. struct type *builtin_type_double;
  52. struct type *builtin_type_long_double;
  53. struct type *builtin_type_complex;
  54. struct type *builtin_type_double_complex;
  55. struct type *builtin_type_string;
  56.  
  57. /* Alloc a new type structure and fill it with some defaults.  If
  58.    OBJFILE is non-NULL, then allocate the space for the type structure
  59.    in that objfile's type_obstack. */
  60.  
  61. struct type *
  62. alloc_type (objfile)
  63.      struct objfile *objfile;
  64. {
  65.   register struct type *type;
  66.  
  67.   /* Alloc the structure and start off with all fields zeroed. */
  68.  
  69.   if (objfile == NULL)
  70.     {
  71.       type  = (struct type *) xmalloc (sizeof (struct type));
  72.     }
  73.   else
  74.     {
  75.       type  = (struct type *) obstack_alloc (&objfile -> type_obstack,
  76.                          sizeof (struct type));
  77.     }
  78.   memset ((char *) type, 0, sizeof (struct type));
  79.  
  80.   /* Initialize the fields that might not be zero. */
  81.  
  82.   TYPE_CODE (type) = TYPE_CODE_UNDEF;
  83.   TYPE_OBJFILE (type) = objfile;
  84.   TYPE_VPTR_FIELDNO (type) = -1;
  85.  
  86.   return (type);
  87. }
  88.  
  89. /* Lookup a pointer to a type TYPE.  TYPEPTR, if nonzero, points
  90.    to a pointer to memory where the pointer type should be stored.
  91.    If *TYPEPTR is zero, update it to point to the pointer type we return.
  92.    We allocate new memory if needed.  */
  93.  
  94. struct type *
  95. make_pointer_type (type, typeptr)
  96.      struct type *type;
  97.      struct type **typeptr;
  98. {
  99.   register struct type *ntype;        /* New type */
  100.   struct objfile *objfile;
  101.  
  102.   ntype = TYPE_POINTER_TYPE (type);
  103.  
  104.   if (ntype) 
  105.     if (typeptr == 0)        
  106.       return ntype;    /* Don't care about alloc, and have new type.  */
  107.     else if (*typeptr == 0)
  108.       {
  109.     *typeptr = ntype;    /* Tracking alloc, and we have new type.  */
  110.     return ntype;
  111.       }
  112.  
  113.   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
  114.     {
  115.       ntype = alloc_type (TYPE_OBJFILE (type));
  116.       if (typeptr)
  117.     *typeptr = ntype;
  118.     }
  119.   else                /* We have storage, but need to reset it.  */
  120.     {
  121.       ntype = *typeptr;
  122.       objfile = TYPE_OBJFILE (ntype);
  123.       memset ((char *) ntype, 0, sizeof (struct type));
  124.       TYPE_OBJFILE (ntype) = objfile;
  125.     }
  126.  
  127.   TYPE_TARGET_TYPE (ntype) = type;
  128.   TYPE_POINTER_TYPE (type) = ntype;
  129.  
  130.   /* FIXME!  Assume the machine has only one representation for pointers!  */
  131.  
  132.   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
  133.   TYPE_CODE (ntype) = TYPE_CODE_PTR;
  134.  
  135.   /* pointers are unsigned */
  136.   TYPE_FLAGS (ntype) |= TYPE_FLAG_UNSIGNED;
  137.   
  138.   if (!TYPE_POINTER_TYPE (type))    /* Remember it, if don't have one.  */
  139.     TYPE_POINTER_TYPE (type) = ntype;
  140.  
  141.   return ntype;
  142. }
  143.  
  144. /* Given a type TYPE, return a type of pointers to that type.
  145.    May need to construct such a type if this is the first use.  */
  146.  
  147. struct type *
  148. lookup_pointer_type (type)
  149.      struct type *type;
  150. {
  151.   return make_pointer_type (type, (struct type **)0);
  152. }
  153.  
  154. /* Lookup a C++ `reference' to a type TYPE.  TYPEPTR, if nonzero, points
  155.    to a pointer to memory where the reference type should be stored.
  156.    If *TYPEPTR is zero, update it to point to the reference type we return.
  157.    We allocate new memory if needed.  */
  158.  
  159. struct type *
  160. make_reference_type (type, typeptr)
  161.      struct type *type;
  162.      struct type **typeptr;
  163. {
  164.   register struct type *ntype;        /* New type */
  165.   struct objfile *objfile;
  166.  
  167.   ntype = TYPE_REFERENCE_TYPE (type);
  168.  
  169.   if (ntype) 
  170.     if (typeptr == 0)        
  171.       return ntype;    /* Don't care about alloc, and have new type.  */
  172.     else if (*typeptr == 0)
  173.       {
  174.     *typeptr = ntype;    /* Tracking alloc, and we have new type.  */
  175.     return ntype;
  176.       }
  177.  
  178.   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
  179.     {
  180.       ntype = alloc_type (TYPE_OBJFILE (type));
  181.       if (typeptr)
  182.     *typeptr = ntype;
  183.     }
  184.   else                /* We have storage, but need to reset it.  */
  185.     {
  186.       ntype = *typeptr;
  187.       objfile = TYPE_OBJFILE (ntype);
  188.       memset ((char *) ntype, 0, sizeof (struct type));
  189.       TYPE_OBJFILE (ntype) = objfile;
  190.     }
  191.  
  192.   TYPE_TARGET_TYPE (ntype) = type;
  193.   TYPE_REFERENCE_TYPE (type) = ntype;
  194.  
  195.   /* FIXME!  Assume the machine has only one representation for references,
  196.      and that it matches the (only) representation for pointers!  */
  197.  
  198.   TYPE_LENGTH (ntype) = TARGET_PTR_BIT / TARGET_CHAR_BIT;
  199.   TYPE_CODE (ntype) = TYPE_CODE_REF;
  200.   
  201.   if (!TYPE_REFERENCE_TYPE (type))    /* Remember it, if don't have one.  */
  202.     TYPE_REFERENCE_TYPE (type) = ntype;
  203.  
  204.   return ntype;
  205. }
  206.  
  207. /* Same as above, but caller doesn't care about memory allocation details.  */
  208.  
  209. struct type *
  210. lookup_reference_type (type)
  211.      struct type *type;
  212. {
  213.   return make_reference_type (type, (struct type **)0);
  214. }
  215.  
  216. /* Lookup a function type that returns type TYPE.  TYPEPTR, if nonzero, points
  217.    to a pointer to memory where the function type should be stored.
  218.    If *TYPEPTR is zero, update it to point to the function type we return.
  219.    We allocate new memory if needed.  */
  220.  
  221. struct type *
  222. make_function_type (type, typeptr)
  223.      struct type *type;
  224.      struct type **typeptr;
  225. {
  226.   register struct type *ntype;        /* New type */
  227.   struct objfile *objfile;
  228.  
  229.   ntype = TYPE_FUNCTION_TYPE (type);
  230.  
  231.   if (ntype) 
  232.     if (typeptr == 0)        
  233.       return ntype;    /* Don't care about alloc, and have new type.  */
  234.     else if (*typeptr == 0)
  235.       {
  236.     *typeptr = ntype;    /* Tracking alloc, and we have new type.  */
  237.     return ntype;
  238.       }
  239.  
  240.   if (typeptr == 0 || *typeptr == 0)    /* We'll need to allocate one.  */
  241.     {
  242.       ntype = alloc_type (TYPE_OBJFILE (type));
  243.       if (typeptr)
  244.     *typeptr = ntype;
  245.     }
  246.   else                /* We have storage, but need to reset it.  */
  247.     {
  248.       ntype = *typeptr;
  249.       objfile = TYPE_OBJFILE (ntype);
  250.       memset ((char *) ntype, 0, sizeof (struct type));
  251.       TYPE_OBJFILE (ntype) = objfile;
  252.     }
  253.  
  254.   TYPE_TARGET_TYPE (ntype) = type;
  255.   TYPE_FUNCTION_TYPE (type) = ntype;
  256.  
  257.   TYPE_LENGTH (ntype) = 1;
  258.   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
  259.   
  260.   if (!TYPE_FUNCTION_TYPE (type))    /* Remember it, if don't have one.  */
  261.     TYPE_FUNCTION_TYPE (type) = ntype;
  262.  
  263.   return ntype;
  264. }
  265.  
  266.  
  267. /* Given a type TYPE, return a type of functions that return that type.
  268.    May need to construct such a type if this is the first use.  */
  269.  
  270. struct type *
  271. lookup_function_type (type)
  272.      struct type *type;
  273. {
  274.   return make_function_type (type, (struct type **)0);
  275. }
  276.  
  277. /* Implement direct support for MEMBER_TYPE in GNU C++.
  278.    May need to construct such a type if this is the first use.
  279.    The TYPE is the type of the member.  The DOMAIN is the type
  280.    of the aggregate that the member belongs to.  */
  281.  
  282. struct type *
  283. lookup_member_type (type, domain)
  284.      struct type *type;
  285.      struct type *domain;
  286. {
  287.   register struct type *mtype;
  288.  
  289.   mtype = alloc_type (TYPE_OBJFILE (type));
  290.   smash_to_member_type (mtype, domain, type);
  291.   return (mtype);
  292. }
  293.  
  294. /* Allocate a stub method whose return type is TYPE.  
  295.    This apparently happens for speed of symbol reading, since parsing
  296.    out the arguments to the method is cpu-intensive, the way we are doing
  297.    it.  So, we will fill in arguments later.
  298.    This always returns a fresh type.   */
  299.  
  300. struct type *
  301. allocate_stub_method (type)
  302.      struct type *type;
  303. {
  304.   struct type *mtype;
  305.  
  306.   mtype = alloc_type (TYPE_OBJFILE (type));
  307.   TYPE_TARGET_TYPE (mtype) = type;
  308.   /*  _DOMAIN_TYPE (mtype) = unknown yet */
  309.   /*  _ARG_TYPES (mtype) = unknown yet */
  310.   TYPE_FLAGS (mtype) = TYPE_FLAG_STUB;
  311.   TYPE_CODE (mtype) = TYPE_CODE_METHOD;
  312.   TYPE_LENGTH (mtype) = 1;
  313.   return (mtype);
  314. }
  315.  
  316. /* Create a range type using either a blank type supplied in RESULT_TYPE,
  317.    or creating a new type, inheriting the objfile from INDEX_TYPE.
  318.  
  319.    Indices will be of type INDEX_TYPE, and will range from LOW_BOUND to
  320.    HIGH_BOUND, inclusive.
  321.  
  322.    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
  323.    sure it is TYPE_CODE_UNDEF before we bash it into a range type? */
  324.  
  325. struct type *
  326. create_range_type (result_type, index_type, low_bound, high_bound)
  327.      struct type *result_type;
  328.      struct type *index_type;
  329.      int low_bound;
  330.      int high_bound;
  331. {
  332.   if (result_type == NULL)
  333.     {
  334.       result_type = alloc_type (TYPE_OBJFILE (index_type));
  335.     }
  336.   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
  337.   TYPE_TARGET_TYPE (result_type) = index_type;
  338.   TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
  339.   TYPE_NFIELDS (result_type) = 2;
  340.   TYPE_FIELDS (result_type) = (struct field *)
  341.     TYPE_ALLOC (result_type, 2 * sizeof (struct field));
  342.   memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
  343.   TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
  344.   TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
  345.   TYPE_FIELD_TYPE (result_type, 0) = builtin_type_int;        /* FIXME */
  346.   TYPE_FIELD_TYPE (result_type, 1) = builtin_type_int;        /* FIXME */
  347.  
  348.   return (result_type);
  349. }
  350.  
  351. /* A lot of code assumes that the "index type" of an array/string/
  352.    set/bitstring is specifically a range type, though in some languages
  353.    it can be any discrete type. */
  354.  
  355. struct type *
  356. force_to_range_type (type)
  357.      struct type *type;
  358. {
  359.   switch (TYPE_CODE (type))
  360.     {
  361.     case TYPE_CODE_RANGE:
  362.       return type;
  363.  
  364.     case TYPE_CODE_ENUM:
  365.       {
  366.     int low_bound = TYPE_FIELD_BITPOS (type, 0);
  367.     int high_bound = TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
  368.     struct type *range_type =
  369.       create_range_type (NULL, type, low_bound, high_bound);
  370.     TYPE_NAME (range_type) = TYPE_NAME (range_type);
  371.     TYPE_DUMMY_RANGE (range_type) = 1;
  372.     return range_type;
  373.       }
  374.     case TYPE_CODE_BOOL:
  375.       {
  376.     struct type *range_type = create_range_type (NULL, type, 0, 1);
  377.     TYPE_NAME (range_type) = TYPE_NAME (range_type);
  378.     TYPE_DUMMY_RANGE (range_type) = 1;
  379.     return range_type;
  380.       }
  381.     case TYPE_CODE_CHAR:
  382.       {
  383.     struct type *range_type = create_range_type (NULL, type, 0, 255);
  384.     TYPE_NAME (range_type) = TYPE_NAME (range_type);
  385.     TYPE_DUMMY_RANGE (range_type) = 1;
  386.     return range_type;
  387.       }
  388.     default:
  389.       {
  390.     static struct complaint msg =
  391.       { "array index type must be a discrete type", 0, 0};
  392.     complain (&msg);
  393.  
  394.     return create_range_type (NULL, builtin_type_int, 0, 0);
  395.       }
  396.     }
  397. }
  398.  
  399. /* Create an array type using either a blank type supplied in RESULT_TYPE,
  400.    or creating a new type, inheriting the objfile from RANGE_TYPE.
  401.  
  402.    Elements will be of type ELEMENT_TYPE, the indices will be of type
  403.    RANGE_TYPE.
  404.  
  405.    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
  406.    sure it is TYPE_CODE_UNDEF before we bash it into an array type? */
  407.  
  408. struct type *
  409. create_array_type (result_type, element_type, range_type)
  410.      struct type *result_type;
  411.      struct type *element_type;
  412.      struct type *range_type;
  413. {
  414.   int low_bound;
  415.   int high_bound;
  416.  
  417.   range_type = force_to_range_type (range_type);
  418.   if (result_type == NULL)
  419.     {
  420.       result_type = alloc_type (TYPE_OBJFILE (range_type));
  421.     }
  422.   TYPE_CODE (result_type) = TYPE_CODE_ARRAY;
  423.   TYPE_TARGET_TYPE (result_type) = element_type;
  424.   low_bound = TYPE_LOW_BOUND (range_type);
  425.   high_bound = TYPE_HIGH_BOUND (range_type);
  426.   TYPE_LENGTH (result_type) =
  427.     TYPE_LENGTH (element_type) * (high_bound - low_bound + 1);
  428.   TYPE_NFIELDS (result_type) = 1;
  429.   TYPE_FIELDS (result_type) =
  430.     (struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
  431.   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
  432.   TYPE_FIELD_TYPE (result_type, 0) = range_type;
  433.   TYPE_VPTR_FIELDNO (result_type) = -1;
  434.  
  435.   return (result_type);
  436. }
  437.  
  438. /* Create a string type using either a blank type supplied in RESULT_TYPE,
  439.    or creating a new type.  String types are similar enough to array of
  440.    char types that we can use create_array_type to build the basic type
  441.    and then bash it into a string type.
  442.  
  443.    For fixed length strings, the range type contains 0 as the lower
  444.    bound and the length of the string minus one as the upper bound.
  445.  
  446.    FIXME:  Maybe we should check the TYPE_CODE of RESULT_TYPE to make
  447.    sure it is TYPE_CODE_UNDEF before we bash it into a string type? */
  448.  
  449. struct type *
  450. create_string_type (result_type, range_type)
  451.      struct type *result_type;
  452.      struct type *range_type;
  453. {
  454.   result_type = create_array_type (result_type, builtin_type_char, range_type);
  455.   TYPE_CODE (result_type) = TYPE_CODE_STRING;
  456.   return (result_type);
  457. }
  458.  
  459. struct type *
  460. create_set_type (result_type, domain_type)
  461.      struct type *result_type;
  462.      struct type *domain_type;
  463. {
  464.   int low_bound, high_bound, bit_length;
  465.   if (result_type == NULL)
  466.     {
  467.       result_type = alloc_type (TYPE_OBJFILE (domain_type));
  468.     }
  469.   domain_type = force_to_range_type (domain_type);
  470.   TYPE_CODE (result_type) = TYPE_CODE_SET;
  471.   TYPE_NFIELDS (result_type) = 1;
  472.   TYPE_FIELDS (result_type) = (struct field *)
  473.     TYPE_ALLOC (result_type, 1 * sizeof (struct field));
  474.   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
  475.   TYPE_FIELD_TYPE (result_type, 0) = domain_type;
  476.   low_bound = TYPE_LOW_BOUND (domain_type);
  477.   high_bound = TYPE_HIGH_BOUND (domain_type);
  478.   bit_length = high_bound - low_bound + 1;
  479.   if (bit_length <= TARGET_CHAR_BIT)
  480.     TYPE_LENGTH (result_type) = 1;
  481.   else if (bit_length <= TARGET_SHORT_BIT)
  482.     TYPE_LENGTH (result_type) = TARGET_SHORT_BIT / TARGET_CHAR_BIT;
  483.   else
  484.     TYPE_LENGTH (result_type)
  485.       = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT)
  486.     * TARGET_CHAR_BIT;
  487.   return (result_type);
  488. }
  489.  
  490. /* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE. 
  491.    A MEMBER is a wierd thing -- it amounts to a typed offset into
  492.    a struct, e.g. "an int at offset 8".  A MEMBER TYPE doesn't
  493.    include the offset (that's the value of the MEMBER itself), but does
  494.    include the structure type into which it points (for some reason).
  495.  
  496.    When "smashing" the type, we preserve the objfile that the
  497.    old type pointed to, since we aren't changing where the type is actually
  498.    allocated.  */
  499.  
  500. void
  501. smash_to_member_type (type, domain, to_type)
  502.      struct type *type;
  503.      struct type *domain;
  504.      struct type *to_type;
  505. {
  506.   struct objfile *objfile;
  507.  
  508.   objfile = TYPE_OBJFILE (type);
  509.  
  510.   memset ((char *) type, 0, sizeof (struct type));
  511.   TYPE_OBJFILE (type) = objfile;
  512.   TYPE_TARGET_TYPE (type) = to_type;
  513.   TYPE_DOMAIN_TYPE (type) = domain;
  514.   TYPE_LENGTH (type) = 1;    /* In practice, this is never needed.  */
  515.   TYPE_CODE (type) = TYPE_CODE_MEMBER;
  516. }
  517.  
  518. /* Smash TYPE to be a type of method of DOMAIN with type TO_TYPE.
  519.    METHOD just means `function that gets an extra "this" argument'.
  520.  
  521.    When "smashing" the type, we preserve the objfile that the
  522.    old type pointed to, since we aren't changing where the type is actually
  523.    allocated.  */
  524.  
  525. void
  526. smash_to_method_type (type, domain, to_type, args)
  527.      struct type *type;
  528.      struct type *domain;
  529.      struct type *to_type;
  530.      struct type **args;
  531. {
  532.   struct objfile *objfile;
  533.  
  534.   objfile = TYPE_OBJFILE (type);
  535.  
  536.   memset ((char *) type, 0, sizeof (struct type));
  537.   TYPE_OBJFILE (type) = objfile;
  538.   TYPE_TARGET_TYPE (type) = to_type;
  539.   TYPE_DOMAIN_TYPE (type) = domain;
  540.   TYPE_ARG_TYPES (type) = args;
  541.   TYPE_LENGTH (type) = 1;    /* In practice, this is never needed.  */
  542.   TYPE_CODE (type) = TYPE_CODE_METHOD;
  543. }
  544.  
  545. /* Return a typename for a struct/union/enum type without "struct ",
  546.    "union ", or "enum ".  If the type has a NULL name, return NULL.  */
  547.  
  548. char *
  549. type_name_no_tag (type)
  550.      register const struct type *type;
  551. {
  552.   if (TYPE_TAG_NAME (type) != NULL)
  553.     return TYPE_TAG_NAME (type);
  554.  
  555.   /* Is there code which expects this to return the name if there is no
  556.      tag name?  My guess is that this is mainly used for C++ in cases where
  557.      the two will always be the same.  */
  558.   return TYPE_NAME (type);
  559. }
  560.  
  561. /* Lookup a primitive type named NAME. 
  562.    Return zero if NAME is not a primitive type.*/
  563.  
  564. struct type *
  565. lookup_primitive_typename (name)
  566.      char *name;
  567. {
  568.    struct type ** const *p;
  569.  
  570.    for (p = current_language -> la_builtin_type_vector; *p != NULL; p++)
  571.      {
  572.        if (STREQ ((**p) -> name, name))
  573.      {
  574.        return (**p);
  575.      }
  576.      }
  577.    return (NULL); 
  578. }
  579.  
  580. /* Lookup a typedef or primitive type named NAME,
  581.    visible in lexical block BLOCK.
  582.    If NOERR is nonzero, return zero if NAME is not suitably defined.  */
  583.  
  584. struct type *
  585. lookup_typename (name, block, noerr)
  586.      char *name;
  587.      struct block *block;
  588.      int noerr;
  589. {
  590.   register struct symbol *sym;
  591.   register struct type *tmp;
  592.  
  593.   sym = lookup_symbol (name, block, VAR_NAMESPACE, 0, (struct symtab **) NULL);
  594.   if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
  595.     {
  596.       tmp = lookup_primitive_typename (name);
  597.       if (tmp)
  598.     {
  599.       return (tmp);
  600.     }
  601.       else if (!tmp && noerr)
  602.     {
  603.       return (NULL);
  604.     }
  605.       else
  606.     {
  607.       error ("No type named %s.", name);
  608.     }
  609.     }
  610.   return (SYMBOL_TYPE (sym));
  611. }
  612.  
  613. struct type *
  614. lookup_unsigned_typename (name)
  615.      char *name;
  616. {
  617.   char *uns = alloca (strlen (name) + 10);
  618.  
  619.   strcpy (uns, "unsigned ");
  620.   strcpy (uns + 9, name);
  621.   return (lookup_typename (uns, (struct block *) NULL, 0));
  622. }
  623.  
  624. struct type *
  625. lookup_signed_typename (name)
  626.      char *name;
  627. {
  628.   struct type *t;
  629.   char *uns = alloca (strlen (name) + 8);
  630.  
  631.   strcpy (uns, "signed ");
  632.   strcpy (uns + 7, name);
  633.   t = lookup_typename (uns, (struct block *) NULL, 1);
  634.   /* If we don't find "signed FOO" just try again with plain "FOO". */
  635.   if (t != NULL)
  636.     return t;
  637.   return lookup_typename (name, (struct block *) NULL, 0);
  638. }
  639.  
  640. /* Lookup a structure type named "struct NAME",
  641.    visible in lexical block BLOCK.  */
  642.  
  643. struct type *
  644. lookup_struct (name, block)
  645.      char *name;
  646.      struct block *block;
  647. {
  648.   register struct symbol *sym;
  649.  
  650.   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
  651.                (struct symtab **) NULL);
  652.  
  653.   if (sym == NULL)
  654.     {
  655.       error ("No struct type named %s.", name);
  656.     }
  657.   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
  658.     {
  659.       error ("This context has class, union or enum %s, not a struct.", name);
  660.     }
  661.   return (SYMBOL_TYPE (sym));
  662. }
  663.  
  664. /* Lookup a union type named "union NAME",
  665.    visible in lexical block BLOCK.  */
  666.  
  667. struct type *
  668. lookup_union (name, block)
  669.      char *name;
  670.      struct block *block;
  671. {
  672.   register struct symbol *sym;
  673.  
  674.   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0,
  675.                (struct symtab **) NULL);
  676.  
  677.   if (sym == NULL)
  678.     {
  679.       error ("No union type named %s.", name);
  680.     }
  681.   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_UNION)
  682.     {
  683.       error ("This context has class, struct or enum %s, not a union.", name);
  684.     }
  685.   return (SYMBOL_TYPE (sym));
  686. }
  687.  
  688. /* Lookup an enum type named "enum NAME",
  689.    visible in lexical block BLOCK.  */
  690.  
  691. struct type *
  692. lookup_enum (name, block)
  693.      char *name;
  694.      struct block *block;
  695. {
  696.   register struct symbol *sym;
  697.  
  698.   sym = lookup_symbol (name, block, STRUCT_NAMESPACE, 0, 
  699.                (struct symtab **) NULL);
  700.   if (sym == NULL)
  701.     {
  702.       error ("No enum type named %s.", name);
  703.     }
  704.   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_ENUM)
  705.     {
  706.       error ("This context has class, struct or union %s, not an enum.", name);
  707.     }
  708.   return (SYMBOL_TYPE (sym));
  709. }
  710.  
  711. /* Lookup a template type named "template NAME<TYPE>",
  712.    visible in lexical block BLOCK.  */
  713.  
  714. struct type *
  715. lookup_template_type (name, type, block)
  716.      char *name;
  717.      struct type *type;
  718.      struct block *block;
  719. {
  720.   struct symbol *sym;
  721.   char *nam = (char*) alloca(strlen(name) + strlen(type->name) + 4);
  722.   strcpy (nam, name);
  723.   strcat (nam, "<");
  724.   strcat (nam, type->name);
  725.   strcat (nam, " >");    /* FIXME, extra space still introduced in gcc? */
  726.  
  727.   sym = lookup_symbol (nam, block, VAR_NAMESPACE, 0, (struct symtab **)NULL);
  728.  
  729.   if (sym == NULL)
  730.     {
  731.       error ("No template type named %s.", name);
  732.     }
  733.   if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
  734.     {
  735.       error ("This context has class, union or enum %s, not a struct.", name);
  736.     }
  737.   return (SYMBOL_TYPE (sym));
  738. }
  739.  
  740. /* Given a type TYPE, lookup the type of the component of type named NAME.  
  741.  
  742.    TYPE can be either a struct or union, or a pointer or reference to a struct or
  743.    union.  If it is a pointer or reference, its target type is automatically used.
  744.    Thus '.' and '->' are interchangable, as specified for the definitions of the
  745.    expression element types STRUCTOP_STRUCT and STRUCTOP_PTR.
  746.  
  747.    If NOERR is nonzero, return zero if NAME is not suitably defined.
  748.    If NAME is the name of a baseclass type, return that type.  */
  749.  
  750. struct type *
  751. lookup_struct_elt_type (type, name, noerr)
  752.      struct type *type;
  753.      char *name;
  754.     int noerr;
  755. {
  756.   int i;
  757.  
  758.   while (TYPE_CODE (type) == TYPE_CODE_PTR ||
  759.       TYPE_CODE (type) == TYPE_CODE_REF)
  760.       type = TYPE_TARGET_TYPE (type);
  761.  
  762.   if (TYPE_CODE (type) != TYPE_CODE_STRUCT &&
  763.       TYPE_CODE (type) != TYPE_CODE_UNION)
  764.     {
  765.       target_terminal_ours ();
  766.       gdb_flush (gdb_stdout);
  767.       fprintf_unfiltered (gdb_stderr, "Type ");
  768.       type_print (type, "", gdb_stderr, -1);
  769.       error (" is not a structure or union type.");
  770.     }
  771.  
  772.   check_stub_type (type);
  773.  
  774. #if 0
  775.   /* FIXME:  This change put in by Michael seems incorrect for the case where
  776.      the structure tag name is the same as the member name.  I.E. when doing
  777.      "ptype bell->bar" for "struct foo { int bar; int foo; } bell;"
  778.      Disabled by fnf. */
  779.   {
  780.     char *typename;
  781.  
  782.     typename = type_name_no_tag (type);
  783.     if (typename != NULL && STREQ (typename, name))
  784.       return type;
  785.   }
  786. #endif
  787.  
  788.   for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
  789.     {
  790.       char *t_field_name = TYPE_FIELD_NAME (type, i);
  791.  
  792.       if (t_field_name && STREQ (t_field_name, name))
  793.     {
  794.       return TYPE_FIELD_TYPE (type, i);
  795.     }
  796.     }
  797.  
  798.   /* OK, it's not in this class.  Recursively check the baseclasses.  */
  799.   for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
  800.     {
  801.       struct type *t;
  802.  
  803.       t = lookup_struct_elt_type (TYPE_BASECLASS (type, i), name, noerr);
  804.       if (t != NULL)
  805.     {
  806.       return t;
  807.     }
  808.     }
  809.  
  810.   if (noerr)
  811.     {
  812.       return NULL;
  813.     }
  814.   
  815.   target_terminal_ours ();
  816.   gdb_flush (gdb_stdout);
  817.   fprintf_unfiltered (gdb_stderr, "Type ");
  818.   type_print (type, "", gdb_stderr, -1);
  819.   fprintf_unfiltered (gdb_stderr, " has no component named ");
  820.   fputs_filtered (name, gdb_stderr);
  821.   error (".");
  822.   return (struct type *)-1;    /* For lint */
  823. }
  824.  
  825. /* If possible, make the vptr_fieldno and vptr_basetype fields of TYPE
  826.    valid.  Callers should be aware that in some cases (for example,
  827.    the type or one of its baseclasses is a stub type and we are
  828.    debugging a .o file), this function will not be able to find the virtual
  829.    function table pointer, and vptr_fieldno will remain -1 and vptr_basetype
  830.    will remain NULL.  */
  831.  
  832. void
  833. fill_in_vptr_fieldno (type)
  834.      struct type *type;
  835. {
  836.   check_stub_type (type);
  837.  
  838.   if (TYPE_VPTR_FIELDNO (type) < 0)
  839.     {
  840.       int i;
  841.  
  842.       /* We must start at zero in case the first (and only) baseclass is
  843.      virtual (and hence we cannot share the table pointer).  */
  844.       for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
  845.     {
  846.       fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
  847.       if (TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i)) >= 0)
  848.         {
  849.           TYPE_VPTR_FIELDNO (type)
  850.         = TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type, i));
  851.           TYPE_VPTR_BASETYPE (type)
  852.         = TYPE_VPTR_BASETYPE (TYPE_BASECLASS (type, i));
  853.           break;
  854.         }
  855.     }
  856.     }
  857. }
  858.  
  859. /* Added by Bryan Boreham, Kewill, Sun Sep 17 18:07:17 1989.
  860.  
  861.    If this is a stubbed struct (i.e. declared as struct foo *), see if
  862.    we can find a full definition in some other file. If so, copy this
  863.    definition, so we can use it in future.  There used to be a comment (but
  864.    not any code) that if we don't find a full definition, we'd set a flag
  865.    so we don't spend time in the future checking the same type.  That would
  866.    be a mistake, though--we might load in more symbols which contain a
  867.    full definition for the type.
  868.  
  869.    This used to be coded as a macro, but I don't think it is called 
  870.    often enough to merit such treatment.  */
  871.  
  872. struct complaint stub_noname_complaint =
  873.   {"stub type has NULL name", 0, 0};
  874.  
  875. void 
  876. check_stub_type (type)
  877.      struct type *type;
  878. {
  879.   if (TYPE_FLAGS(type) & TYPE_FLAG_STUB)
  880.     {
  881.       char* name = type_name_no_tag (type);
  882.       /* FIXME: shouldn't we separately check the TYPE_NAME and the
  883.      TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
  884.      as appropriate?  (this code was written before TYPE_NAME and
  885.      TYPE_TAG_NAME were separate).  */
  886.       struct symbol *sym;
  887.       if (name == NULL)
  888.     {
  889.       complain (&stub_noname_complaint);
  890.       return;
  891.     }
  892.       sym = lookup_symbol (name, 0, STRUCT_NAMESPACE, 0, 
  893.                (struct symtab **) NULL);
  894.       if (sym)
  895.     {
  896.       memcpy ((char *)type,
  897.           (char *)SYMBOL_TYPE(sym),
  898.           sizeof (struct type));
  899.     }
  900.     }
  901.  
  902.   if (TYPE_FLAGS (type) & TYPE_FLAG_TARGET_STUB)
  903.     {
  904.       struct type *range_type;
  905.  
  906.       check_stub_type (TYPE_TARGET_TYPE (type));
  907.       if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
  908.       && TYPE_CODE (type) == TYPE_CODE_ARRAY
  909.       && TYPE_NFIELDS (type) == 1
  910.       && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
  911.           == TYPE_CODE_RANGE))
  912.     {
  913.       /* Now recompute the length of the array type, based on its
  914.          number of elements and the target type's length.  */
  915.       TYPE_LENGTH (type) =
  916.         ((TYPE_FIELD_BITPOS (range_type, 1)
  917.           - TYPE_FIELD_BITPOS (range_type, 0)
  918.           + 1)
  919.          * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
  920.       TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
  921.     }
  922.     }
  923. }
  924.  
  925. /* Ugly hack to convert method stubs into method types.
  926.  
  927.    He ain't kiddin'.  This demangles the name of the method into a string
  928.    including argument types, parses out each argument type, generates
  929.    a string casting a zero to that type, evaluates the string, and stuffs
  930.    the resulting type into an argtype vector!!!  Then it knows the type
  931.    of the whole function (including argument types for overloading),
  932.    which info used to be in the stab's but was removed to hack back
  933.    the space required for them.  */
  934.  
  935. void
  936. check_stub_method (type, i, j)
  937.      struct type *type;
  938.      int i;
  939.      int j;
  940. {
  941.   struct fn_field *f;
  942.   char *mangled_name = gdb_mangle_name (type, i, j);
  943.   char *demangled_name = cplus_demangle (mangled_name,
  944.                      DMGL_PARAMS | DMGL_ANSI);
  945.   char *argtypetext, *p;
  946.   int depth = 0, argcount = 1;
  947.   struct type **argtypes;
  948.   struct type *mtype;
  949.  
  950.   if (demangled_name == NULL)
  951.     {
  952.       error ("Internal: Cannot demangle mangled name `%s'.", mangled_name);
  953.     }
  954.  
  955.   /* Now, read in the parameters that define this type.  */
  956.   argtypetext = strchr (demangled_name, '(') + 1;
  957.   p = argtypetext;
  958.   while (*p)
  959.     {
  960.       if (*p == '(')
  961.     {
  962.       depth += 1;
  963.     }
  964.       else if (*p == ')')
  965.     {
  966.       depth -= 1;
  967.     }
  968.       else if (*p == ',' && depth == 0)
  969.     {
  970.       argcount += 1;
  971.     }
  972.  
  973.       p += 1;
  974.     }
  975.  
  976.   /* We need two more slots: one for the THIS pointer, and one for the
  977.      NULL [...] or void [end of arglist].  */
  978.  
  979.   argtypes = (struct type **)
  980.     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
  981.   p = argtypetext;
  982.   argtypes[0] = lookup_pointer_type (type);
  983.   argcount = 1;
  984.  
  985.   if (*p != ')')            /* () means no args, skip while */
  986.     {
  987.       depth = 0;
  988.       while (*p)
  989.     {
  990.       if (depth <= 0 && (*p == ',' || *p == ')'))
  991.         {
  992.           /* Avoid parsing of ellipsis, they will be handled below.  */
  993.           if (strncmp (argtypetext, "...", p - argtypetext) != 0)
  994.         {
  995.           argtypes[argcount] =
  996.               parse_and_eval_type (argtypetext, p - argtypetext);
  997.           argcount += 1;
  998.         }
  999.           argtypetext = p + 1;
  1000.         }
  1001.  
  1002.       if (*p == '(')
  1003.         {
  1004.           depth += 1;
  1005.         }
  1006.       else if (*p == ')')
  1007.         {
  1008.           depth -= 1;
  1009.         }
  1010.  
  1011.       p += 1;
  1012.     }
  1013.     }
  1014.  
  1015.   if (p[-2] != '.')            /* Not '...' */
  1016.     {
  1017.       argtypes[argcount] = builtin_type_void;    /* List terminator */
  1018.     }
  1019.   else
  1020.     {
  1021.       argtypes[argcount] = NULL;        /* Ellist terminator */
  1022.     }
  1023.  
  1024.   free (demangled_name);
  1025.  
  1026.   f = TYPE_FN_FIELDLIST1 (type, i);
  1027.   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
  1028.  
  1029.   /* Now update the old "stub" type into a real type.  */
  1030.   mtype = TYPE_FN_FIELD_TYPE (f, j);
  1031.   TYPE_DOMAIN_TYPE (mtype) = type;
  1032.   TYPE_ARG_TYPES (mtype) = argtypes;
  1033.   TYPE_FLAGS (mtype) &= ~TYPE_FLAG_STUB;
  1034.   TYPE_FN_FIELD_STUB (f, j) = 0;
  1035. }
  1036.  
  1037. const struct cplus_struct_type cplus_struct_default;
  1038.  
  1039. void
  1040. allocate_cplus_struct_type (type)
  1041.      struct type *type;
  1042. {
  1043.   if (!HAVE_CPLUS_STRUCT (type))
  1044.     {
  1045.       TYPE_CPLUS_SPECIFIC (type) = (struct cplus_struct_type *)
  1046.     TYPE_ALLOC (type, sizeof (struct cplus_struct_type));
  1047.       *(TYPE_CPLUS_SPECIFIC(type)) = cplus_struct_default;
  1048.     }
  1049. }
  1050.  
  1051. /* Helper function to initialize the standard scalar types.
  1052.  
  1053.    If NAME is non-NULL and OBJFILE is non-NULL, then we make a copy
  1054.    of the string pointed to by name in the type_obstack for that objfile,
  1055.    and initialize the type name to that copy.  There are places (mipsread.c
  1056.    in particular, where init_type is called with a NULL value for NAME). */
  1057.  
  1058. struct type *
  1059. init_type (code, length, flags, name, objfile)
  1060.      enum type_code code;
  1061.      int length;
  1062.      int flags;
  1063.      char *name;
  1064.      struct objfile *objfile;
  1065. {
  1066.   register struct type *type;
  1067.  
  1068.   type = alloc_type (objfile);
  1069.   TYPE_CODE (type) = code;
  1070.   TYPE_LENGTH (type) = length;
  1071.   TYPE_FLAGS (type) |= flags;
  1072.   if ((name != NULL) && (objfile != NULL))
  1073.     {
  1074.       TYPE_NAME (type) =
  1075.     obsavestring (name, strlen (name), &objfile -> type_obstack);
  1076.     }
  1077.   else
  1078.     {
  1079.       TYPE_NAME (type) = name;
  1080.     }
  1081.  
  1082.   /* C++ fancies.  */
  1083.  
  1084.   if (code == TYPE_CODE_STRUCT || code == TYPE_CODE_UNION)
  1085.     {
  1086.       INIT_CPLUS_SPECIFIC (type);
  1087.     }
  1088.   return (type);
  1089. }
  1090.  
  1091. /* Look up a fundamental type for the specified objfile.
  1092.    May need to construct such a type if this is the first use.
  1093.  
  1094.    Some object file formats (ELF, COFF, etc) do not define fundamental
  1095.    types such as "int" or "double".  Others (stabs for example), do
  1096.    define fundamental types.
  1097.  
  1098.    For the formats which don't provide fundamental types, gdb can create
  1099.    such types, using defaults reasonable for the current language and
  1100.    the current target machine.
  1101.  
  1102.    NOTE:  This routine is obsolescent.  Each debugging format reader
  1103.    should manage it's own fundamental types, either creating them from
  1104.    suitable defaults or reading them from the debugging information,
  1105.    whichever is appropriate.  The DWARF reader has already been
  1106.    fixed to do this.  Once the other readers are fixed, this routine
  1107.    will go away.  Also note that fundamental types should be managed
  1108.    on a compilation unit basis in a multi-language environment, not
  1109.    on a linkage unit basis as is done here. */
  1110.  
  1111.  
  1112. struct type *
  1113. lookup_fundamental_type (objfile, typeid)
  1114.      struct objfile *objfile;
  1115.      int typeid;
  1116. {
  1117.   register struct type **typep;
  1118.   register int nbytes;
  1119.  
  1120.   if (typeid < 0 || typeid >= FT_NUM_MEMBERS)
  1121.     {
  1122.       error ("internal error - invalid fundamental type id %d", typeid);
  1123.     }
  1124.  
  1125.   /* If this is the first time we need a fundamental type for this objfile
  1126.      then we need to initialize the vector of type pointers. */
  1127.   
  1128.   if (objfile -> fundamental_types == NULL)
  1129.     {
  1130.       nbytes = FT_NUM_MEMBERS * sizeof (struct type *);
  1131.       objfile -> fundamental_types = (struct type **)
  1132.     obstack_alloc (&objfile -> type_obstack, nbytes);
  1133.       memset ((char *) objfile -> fundamental_types, 0, nbytes);
  1134.     }
  1135.  
  1136.   /* Look for this particular type in the fundamental type vector.  If one is
  1137.      not found, create and install one appropriate for the current language. */
  1138.  
  1139.   typep = objfile -> fundamental_types + typeid;
  1140.   if (*typep == NULL)
  1141.     {
  1142.       *typep = create_fundamental_type (objfile, typeid);
  1143.     }
  1144.  
  1145.   return (*typep);
  1146. }
  1147.  
  1148. #if MAINTENANCE_CMDS
  1149.  
  1150. static void
  1151. print_bit_vector (bits, nbits)
  1152.      B_TYPE *bits;
  1153.      int nbits;
  1154. {
  1155.   int bitno;
  1156.  
  1157.   for (bitno = 0; bitno < nbits; bitno++)
  1158.     {
  1159.       if ((bitno % 8) == 0)
  1160.     {
  1161.       puts_filtered (" ");
  1162.     }
  1163.       if (B_TST (bits, bitno))
  1164.     {
  1165.       printf_filtered ("1");
  1166.     }
  1167.       else
  1168.     {
  1169.       printf_filtered ("0");
  1170.     }
  1171.     }
  1172. }
  1173.  
  1174. /* The args list is a strange beast.  It is either terminated by a NULL
  1175.    pointer for varargs functions, or by a pointer to a TYPE_CODE_VOID
  1176.    type for normal fixed argcount functions.  (FIXME someday)
  1177.    Also note the first arg should be the "this" pointer, we may not want to
  1178.    include it since we may get into a infinitely recursive situation. */
  1179.  
  1180. static void
  1181. print_arg_types (args, spaces)
  1182.      struct type **args;
  1183.      int spaces;
  1184. {
  1185.   if (args != NULL)
  1186.     {
  1187.       while (*args != NULL)
  1188.     {
  1189.       recursive_dump_type (*args, spaces + 2);
  1190.       if ((*args++) -> code == TYPE_CODE_VOID)
  1191.         {
  1192.           break;
  1193.         }
  1194.     }
  1195.     }
  1196. }
  1197.  
  1198. static void
  1199. dump_fn_fieldlists (type, spaces)
  1200.      struct type *type;
  1201.      int spaces;
  1202. {
  1203.   int method_idx;
  1204.   int overload_idx;
  1205.   struct fn_field *f;
  1206.  
  1207.   printfi_filtered (spaces, "fn_fieldlists 0x%lx\n",
  1208.             (unsigned long) TYPE_FN_FIELDLISTS (type));
  1209.   for (method_idx = 0; method_idx < TYPE_NFN_FIELDS (type); method_idx++)
  1210.     {
  1211.       f = TYPE_FN_FIELDLIST1 (type, method_idx);
  1212.       printfi_filtered (spaces + 2, "[%d] name '%s' (0x%lx) length %d\n",
  1213.             method_idx,
  1214.             TYPE_FN_FIELDLIST_NAME (type, method_idx),
  1215.             (unsigned long) TYPE_FN_FIELDLIST_NAME (type, method_idx),
  1216.             TYPE_FN_FIELDLIST_LENGTH (type, method_idx));
  1217.       for (overload_idx = 0;
  1218.        overload_idx < TYPE_FN_FIELDLIST_LENGTH (type, method_idx);
  1219.        overload_idx++)
  1220.     {
  1221.       printfi_filtered (spaces + 4, "[%d] physname '%s' (0x%lx)\n",
  1222.                 overload_idx,
  1223.                 TYPE_FN_FIELD_PHYSNAME (f, overload_idx),
  1224.                 (unsigned long) TYPE_FN_FIELD_PHYSNAME (f, overload_idx));
  1225.       printfi_filtered (spaces + 8, "type 0x%lx\n",
  1226.                 (unsigned long) TYPE_FN_FIELD_TYPE (f, overload_idx));
  1227.       recursive_dump_type (TYPE_FN_FIELD_TYPE (f, overload_idx),
  1228.                    spaces + 8 + 2);
  1229.       printfi_filtered (spaces + 8, "args 0x%lx\n",
  1230.                 (unsigned long) TYPE_FN_FIELD_ARGS (f, overload_idx));
  1231.       print_arg_types (TYPE_FN_FIELD_ARGS (f, overload_idx), spaces);
  1232.       printfi_filtered (spaces + 8, "fcontext 0x%lx\n",
  1233.                 (unsigned long) TYPE_FN_FIELD_FCONTEXT (f, overload_idx));
  1234.       printfi_filtered (spaces + 8, "is_const %d\n",
  1235.                 TYPE_FN_FIELD_CONST (f, overload_idx));
  1236.       printfi_filtered (spaces + 8, "is_volatile %d\n",
  1237.                 TYPE_FN_FIELD_VOLATILE (f, overload_idx));
  1238.       printfi_filtered (spaces + 8, "is_private %d\n",
  1239.                 TYPE_FN_FIELD_PRIVATE (f, overload_idx));
  1240.       printfi_filtered (spaces + 8, "is_protected %d\n",
  1241.                 TYPE_FN_FIELD_PROTECTED (f, overload_idx));
  1242.       printfi_filtered (spaces + 8, "is_stub %d\n",
  1243.                 TYPE_FN_FIELD_STUB (f, overload_idx));
  1244.       printfi_filtered (spaces + 8, "voffset %u\n",
  1245.                 TYPE_FN_FIELD_VOFFSET (f, overload_idx));
  1246.     }
  1247.     }
  1248. }
  1249.  
  1250. static void
  1251. print_cplus_stuff (type, spaces)
  1252.      struct type *type;
  1253.      int spaces;
  1254. {
  1255.   printfi_filtered (spaces, "n_baseclasses %d\n",
  1256.             TYPE_N_BASECLASSES (type));
  1257.   printfi_filtered (spaces, "nfn_fields %d\n",
  1258.             TYPE_NFN_FIELDS (type));
  1259.   printfi_filtered (spaces, "nfn_fields_total %d\n",
  1260.             TYPE_NFN_FIELDS_TOTAL (type));
  1261.   if (TYPE_N_BASECLASSES (type) > 0)
  1262.     {
  1263.       printfi_filtered (spaces, "virtual_field_bits (%d bits at *0x%lx)",
  1264.             TYPE_N_BASECLASSES (type),
  1265.             (unsigned long) TYPE_FIELD_VIRTUAL_BITS (type));
  1266.       print_bit_vector (TYPE_FIELD_VIRTUAL_BITS (type),
  1267.             TYPE_N_BASECLASSES (type));
  1268.       puts_filtered ("\n");
  1269.     }
  1270.   if (TYPE_NFIELDS (type) > 0)
  1271.     {
  1272.       if (TYPE_FIELD_PRIVATE_BITS (type) != NULL)
  1273.     {
  1274.       printfi_filtered (spaces, "private_field_bits (%d bits at *0x%lx)",
  1275.                 TYPE_NFIELDS (type),
  1276.                 (unsigned long) TYPE_FIELD_PRIVATE_BITS (type));
  1277.       print_bit_vector (TYPE_FIELD_PRIVATE_BITS (type),
  1278.                 TYPE_NFIELDS (type));
  1279.       puts_filtered ("\n");
  1280.     }
  1281.       if (TYPE_FIELD_PROTECTED_BITS (type) != NULL)
  1282.     {
  1283.       printfi_filtered (spaces, "protected_field_bits (%d bits at *0x%lx)",
  1284.                 TYPE_NFIELDS (type),
  1285.                 (unsigned long) TYPE_FIELD_PROTECTED_BITS (type));
  1286.       print_bit_vector (TYPE_FIELD_PROTECTED_BITS (type),
  1287.                 TYPE_NFIELDS (type));
  1288.       puts_filtered ("\n");
  1289.     }
  1290.     }
  1291.   if (TYPE_NFN_FIELDS (type) > 0)
  1292.     {
  1293.       dump_fn_fieldlists (type, spaces);
  1294.     }
  1295. }
  1296.  
  1297. void
  1298. recursive_dump_type (type, spaces)
  1299.      struct type *type;
  1300.      int spaces;
  1301. {
  1302.   int idx;
  1303.  
  1304.   printfi_filtered (spaces, "type node 0x%lx\n", (unsigned long)type);
  1305.   printfi_filtered (spaces, "name '%s' (0x%lx)\n",
  1306.             TYPE_NAME (type) ? TYPE_NAME (type) : "<NULL>",
  1307.             (unsigned long)TYPE_NAME (type));
  1308.   if (TYPE_TAG_NAME (type) != NULL)
  1309.     printfi_filtered (spaces, "tagname '%s' (0x%lx)\n",
  1310.               TYPE_TAG_NAME (type),
  1311.               (unsigned long)TYPE_TAG_NAME (type));
  1312.   printfi_filtered (spaces, "code 0x%x ", TYPE_CODE (type));
  1313.   switch (TYPE_CODE (type))
  1314.     {
  1315.       case TYPE_CODE_UNDEF:
  1316.         printf_filtered ("(TYPE_CODE_UNDEF)");
  1317.     break;
  1318.       case TYPE_CODE_PTR:
  1319.     printf_filtered ("(TYPE_CODE_PTR)");
  1320.     break;
  1321.       case TYPE_CODE_ARRAY:
  1322.     printf_filtered ("(TYPE_CODE_ARRAY)");
  1323.     break;
  1324.       case TYPE_CODE_STRUCT:
  1325.     printf_filtered ("(TYPE_CODE_STRUCT)");
  1326.     break;
  1327.       case TYPE_CODE_UNION:
  1328.     printf_filtered ("(TYPE_CODE_UNION)");
  1329.     break;
  1330.       case TYPE_CODE_ENUM:
  1331.     printf_filtered ("(TYPE_CODE_ENUM)");
  1332.     break;
  1333.       case TYPE_CODE_FUNC:
  1334.     printf_filtered ("(TYPE_CODE_FUNC)");
  1335.     break;
  1336.       case TYPE_CODE_INT:
  1337.     printf_filtered ("(TYPE_CODE_INT)");
  1338.     break;
  1339.       case TYPE_CODE_FLT:
  1340.     printf_filtered ("(TYPE_CODE_FLT)");
  1341.     break;
  1342.       case TYPE_CODE_VOID:
  1343.     printf_filtered ("(TYPE_CODE_VOID)");
  1344.     break;
  1345.       case TYPE_CODE_SET:
  1346.     printf_filtered ("(TYPE_CODE_SET)");
  1347.     break;
  1348.       case TYPE_CODE_RANGE:
  1349.     printf_filtered ("(TYPE_CODE_RANGE)");
  1350.     break;
  1351.       case TYPE_CODE_STRING:
  1352.     printf_filtered ("(TYPE_CODE_STRING)");
  1353.     break;
  1354.       case TYPE_CODE_ERROR:
  1355.     printf_filtered ("(TYPE_CODE_ERROR)");
  1356.     break;
  1357.       case TYPE_CODE_MEMBER:
  1358.     printf_filtered ("(TYPE_CODE_MEMBER)");
  1359.     break;
  1360.       case TYPE_CODE_METHOD:
  1361.     printf_filtered ("(TYPE_CODE_METHOD)");
  1362.     break;
  1363.       case TYPE_CODE_REF:
  1364.     printf_filtered ("(TYPE_CODE_REF)");
  1365.     break;
  1366.       case TYPE_CODE_CHAR:
  1367.     printf_filtered ("(TYPE_CODE_CHAR)");
  1368.     break;
  1369.       case TYPE_CODE_BOOL:
  1370.     printf_filtered ("(TYPE_CODE_BOOL)");
  1371.     break;
  1372.       default:
  1373.     printf_filtered ("(UNKNOWN TYPE CODE)");
  1374.     break;
  1375.     }
  1376.   puts_filtered ("\n");
  1377.   printfi_filtered (spaces, "length %d\n", TYPE_LENGTH (type));
  1378.   printfi_filtered (spaces, "objfile 0x%lx\n",
  1379.             (unsigned long) TYPE_OBJFILE (type));
  1380.   printfi_filtered (spaces, "target_type 0x%lx\n",
  1381.             (unsigned long) TYPE_TARGET_TYPE (type));
  1382.   if (TYPE_TARGET_TYPE (type) != NULL)
  1383.     {
  1384.       recursive_dump_type (TYPE_TARGET_TYPE (type), spaces + 2);
  1385.     }
  1386.   printfi_filtered (spaces, "pointer_type 0x%lx\n",
  1387.             (unsigned long) TYPE_POINTER_TYPE (type));
  1388.   printfi_filtered (spaces, "reference_type 0x%lx\n",
  1389.             (unsigned long) TYPE_REFERENCE_TYPE (type));
  1390.   printfi_filtered (spaces, "function_type 0x%lx\n",
  1391.             (unsigned long) TYPE_FUNCTION_TYPE (type));
  1392.   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
  1393.   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
  1394.     {
  1395.       puts_filtered (" TYPE_FLAG_UNSIGNED");
  1396.     }
  1397.   if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
  1398.     {
  1399.       puts_filtered (" TYPE_FLAG_STUB");
  1400.     }
  1401.   puts_filtered ("\n");
  1402.   printfi_filtered (spaces, "nfields %d 0x%lx\n", TYPE_NFIELDS (type),
  1403.             (unsigned long) TYPE_FIELDS (type));
  1404.   for (idx = 0; idx < TYPE_NFIELDS (type); idx++)
  1405.     {
  1406.       printfi_filtered (spaces + 2,
  1407.             "[%d] bitpos %d bitsize %d type 0x%lx name '%s' (0x%lx)\n",
  1408.             idx, TYPE_FIELD_BITPOS (type, idx),
  1409.             TYPE_FIELD_BITSIZE (type, idx),
  1410.             (unsigned long) TYPE_FIELD_TYPE (type, idx),
  1411.             TYPE_FIELD_NAME (type, idx) != NULL
  1412.               ? TYPE_FIELD_NAME (type, idx)
  1413.               : "<NULL>",
  1414.             (unsigned long) TYPE_FIELD_NAME (type, idx));
  1415.       if (TYPE_FIELD_TYPE (type, idx) != NULL)
  1416.     {
  1417.       recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
  1418.     }
  1419.     }
  1420.   printfi_filtered (spaces, "vptr_basetype 0x%lx\n",
  1421.             (unsigned long) TYPE_VPTR_BASETYPE (type));
  1422.   if (TYPE_VPTR_BASETYPE (type) != NULL)
  1423.     {
  1424.       recursive_dump_type (TYPE_VPTR_BASETYPE (type), spaces + 2);
  1425.     }
  1426.   printfi_filtered (spaces, "vptr_fieldno %d\n", TYPE_VPTR_FIELDNO (type));
  1427.   switch (TYPE_CODE (type))
  1428.     {
  1429.       case TYPE_CODE_METHOD:
  1430.       case TYPE_CODE_FUNC:
  1431.     printfi_filtered (spaces, "arg_types 0x%lx\n",
  1432.               (unsigned long) TYPE_ARG_TYPES (type));
  1433.     print_arg_types (TYPE_ARG_TYPES (type), spaces);
  1434.     break;
  1435.  
  1436.       case TYPE_CODE_STRUCT:
  1437.     printfi_filtered (spaces, "cplus_stuff 0x%lx\n",
  1438.               (unsigned long) TYPE_CPLUS_SPECIFIC (type));
  1439.     print_cplus_stuff (type, spaces);
  1440.     break;
  1441.  
  1442.       default:
  1443.     /* We have to pick one of the union types to be able print and test
  1444.        the value.  Pick cplus_struct_type, even though we know it isn't
  1445.        any particular one. */
  1446.     printfi_filtered (spaces, "type_specific 0x%lx",
  1447.               (unsigned long) TYPE_CPLUS_SPECIFIC (type));
  1448.     if (TYPE_CPLUS_SPECIFIC (type) != NULL)
  1449.       {
  1450.         printf_filtered (" (unknown data form)");
  1451.       }
  1452.     printf_filtered ("\n");
  1453.     break;
  1454.  
  1455.     }
  1456. }
  1457.  
  1458. #endif    /* MAINTENANCE_CMDS */
  1459.  
  1460. void
  1461. _initialize_gdbtypes ()
  1462. {
  1463.   builtin_type_void =
  1464.     init_type (TYPE_CODE_VOID, 1,
  1465.            0,
  1466.            "void", (struct objfile *) NULL);
  1467.   builtin_type_char =
  1468.     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
  1469.            0,
  1470.            "char", (struct objfile *) NULL);
  1471.   builtin_type_signed_char =
  1472.     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
  1473.            0,
  1474.            "signed char", (struct objfile *) NULL);
  1475.   builtin_type_unsigned_char =
  1476.     init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
  1477.            TYPE_FLAG_UNSIGNED,
  1478.            "unsigned char", (struct objfile *) NULL);
  1479.   builtin_type_short =
  1480.     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
  1481.            0,
  1482.            "short", (struct objfile *) NULL);
  1483.   builtin_type_unsigned_short =
  1484.     init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT,
  1485.            TYPE_FLAG_UNSIGNED,
  1486.            "unsigned short", (struct objfile *) NULL);
  1487.   builtin_type_int =
  1488.     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
  1489.            0,
  1490.            "int", (struct objfile *) NULL);
  1491.   builtin_type_unsigned_int =
  1492.     init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT,
  1493.            TYPE_FLAG_UNSIGNED,
  1494.            "unsigned int", (struct objfile *) NULL);
  1495.   builtin_type_long =
  1496.     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
  1497.            0,
  1498.            "long", (struct objfile *) NULL);
  1499.   builtin_type_unsigned_long =
  1500.     init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
  1501.            TYPE_FLAG_UNSIGNED,
  1502.            "unsigned long", (struct objfile *) NULL);
  1503.   builtin_type_long_long =
  1504.     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
  1505.            0,
  1506.            "long long", (struct objfile *) NULL);
  1507.   builtin_type_unsigned_long_long = 
  1508.     init_type (TYPE_CODE_INT, TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
  1509.            TYPE_FLAG_UNSIGNED,
  1510.            "unsigned long long", (struct objfile *) NULL);
  1511.   builtin_type_float =
  1512.     init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
  1513.            0,
  1514.            "float", (struct objfile *) NULL);
  1515.   builtin_type_double =
  1516.     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
  1517.            0,
  1518.            "double", (struct objfile *) NULL);
  1519.   builtin_type_long_double =
  1520.     init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
  1521.            0,
  1522.            "long double", (struct objfile *) NULL);
  1523.   builtin_type_complex =
  1524.     init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
  1525.            0,
  1526.            "complex", (struct objfile *) NULL);
  1527.   builtin_type_double_complex =
  1528.     init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
  1529.            0,
  1530.            "double complex", (struct objfile *) NULL);
  1531.   builtin_type_string =
  1532.     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
  1533.            0,
  1534.            "string", (struct objfile *) NULL);
  1535. }
  1536.